Description

This assignment centers on the scripting backbone of XR in Unity, emphasizing decision logic, methods, collections, the MonoBehaviour lifecycle, and the organization power of namespaces. You will build the custom logic engines and components that could later drive those interactions.

Goals

Implement clear decision-making logic and reusable methods in C#.
Use collections for managing state and groups of entities.
Author and correctly use MonoBehaviour scripts with appropriate lifecycle methods.
Communicate architecture and behavior through documentation.

Requirements

Design and implement a suite of Unity C# MonoBehaviour components that encapsulate a small XFactory subsystem (logic, state, and decision-making). Examples: a drone coordinator that “flies” to scan barcodes, queues retry logic, and escalates inventory mismatches; an AGV/AMR delivery planner that routes around dynamic obstacles, prioritizes urgent shipments, and falls back on failures; or a lighting/access supervisor that switches modes (normal, energy-save, emergency), locks/unlocks zones, and raises tiered alerts based on simulated sensor inputs.

MonoBehaviour Scripts: Create at least three custom C# MonoBehaviour scripts demonstrating:
- Decision logic (if/switch, for, do-while) with clear branching.
- Methods with parameters and return values supporting reuse.
- Use of collections (List, Dictionary, or both) to manage dynamic sets of stateful objects or events.
Lifecycle Awareness: Use MonoBehaviour lifecycle methods appropriately (Start(), Update(), OnEnable()/OnDisable(), and at least one simulated event).
Driver Scene: Provide a Unity scene or console/UI interface where the logic can be exercised (e.g., toggling modes, injecting simulated inputs, viewing aggregated output).

Prepare a Code Overview Document (≤ 1 page) explaining the architecture, namespace structure, decision logic flow, and how the components relate.

Keep abstraction simple—depth is less important than clarity and correct separation. Target ~6–8 hours effort; clarity of logic and explanation outweigh clever but opaque code.

Graduate Extension

Graduate students augment the core assignment by grounding component design in recent research from premier venues:

Focused Literature Review:
- Select 3–4 peer-reviewed publications from top-tier venues such as IEEE ISMAR, IEEE VR, ACM CHI, ACM UIST, ACM DIS, or similar human-computer interaction / immersive systems conferences that explore topics relevant to logic, state management, adaptation, or system organization in XR for engineering contexts (examples: context-aware system decision frameworks in AR/VR, cognitive load-aware mode switching, scalable modular architecture for real-time interactive systems).
- Provide concise summaries (≤250 words per paper) highlighting: the engineering challenge, how XR systems structured decision or logic, and any architectural/design insight you can borrow.
Research-Informed Enhancement Proposal:
- Based on that literature, define one specific enhancement or design refinement to your logic suite. Examples include introducing a pluggable policy layer for mode selection inspired by adaptive systems research, or applying a prioritization schema for alerts based on findings about operator attention in immersive interfaces.
- Write a Research Memo Document (≤ 2 pages) that connects the literature to your system design, describes the enhancement conceptually (and, if feasible, sketches its integration), and reflects on anticipated benefits or design trade-offs in the engineering XR setting.

Submission

Deliverables

UnityPackage file (.unitypackage) containing all scripts and any supporting assets you created for the assignment. Export only your personal folder created inside Assets/ and named with your full name (e.g., Assets/FirstName_LastName/).
A working driver scene or harness that demonstrates and tests your logic.
Code Overview Document (PDF) explaining architecture, namespaces, and decision flows.
Flowchart or diagram of your decision logic.
(Graduate students only) Literature summaries, research memo, comparison write-up, and two implementations demonstrating the alternative styles.

Guidelines

Submissions must be made individually.
Submit your .unitypackage file, Code Overview Document, and (if applicable) Research Memo via Canvas.
To create your submission:
1. In the Unity Project window, right-click your personal folder (Assets/FirstName_LastName).
2. Select Export Package….
3. Check Include Dependencies (to capture any required scripts, prefabs, or test scenes).
4. Name your file AC_FirstName_LastName.unitypackage.
Double-check your UnityPackage by importing it into a fresh copy of the base project to ensure nothing is missing.
Your Code Overview Document must include:
- The subsystem chosen.
- How to run or test the logic.
- Explanation of namespaces used.
- (For graduate students) Full citations of reviewed papers (standard reference format).
Use clear naming conventions separating core vs. graduate extension code (e.g., namespace labels, folder grad_extension/).
Provide sample inputs/triggers and expected outputs so a reviewer can easily test your implementation.
Filename conventions:
- AC_FirstName_LastName.unitypackage
- CodeOverview_FirstName_LastName.pdf.
- LitReview_FirstName_LastName.pdf (for graduate students).

Grading Rubric

Undergraduate Core (100 points)

Criterion	Description	Points
MonoBehaviour & Lifecycle Usage	Appropriate use of lifecycle methods; clear separation of responsibilities.	29
Decision Logic & Methods	Well-structured branching logic; reusable methods; documented flow via flowchart.	29
Collections & State Management	Effective use of Lists/Dictionaries; safe iteration; state updates reflected.	22
Namespace Organization	Logical grouping using namespaces; avoids naming collisions; clarity of boundaries.	20

Graduate Extension Add-On (up to 20 points)

Criterion	Description	Points
Literature Review Relevance & Quality	Appropriate paper selection from allowed venues; accurate summaries; relevance to XR engineering logic.	8
Enhancement Framing & Insight	Clear linkage between literature and proposed refinement; thoughtfulness about engineering impact.	7
Alternative Implementation Comparison	Two distinct variants provided; comparison shows understanding of trade-offs.	5